/**
 * 定义配置变量
 */
var visiter = '游客';
var pic = "./assets/images/index/avatar-red2.png";//用户头像
var robotImg = "./assets/images/index/workerman_logo.png";//机器人头像
var firstWlcome = true;//首次进入调用对话接口
var baseUrl = 'http://192.168.69.182';
var messageChatApi = baseUrl + "/v1/chat-messages";//对话接口
var documentApi = baseUrl + ":17938/document";//文档接口
var saveOrderApi = baseUrl + ":17938/save_order";//保存订单接口
var delConversationApi = baseUrl + "/v1/conversations";//删除会话接口
var resolutionsUrl = baseUrl + ":17938/get_resolution";//获取所有分辨率接口
var assemblyUrl = baseUrl + ":17938/select_assembly";//获取总成数据接口
var languageUrl = baseUrl + ":17938/select_language";//获取语言数据接口
var uploadUrl = baseUrl + ":17938/upload";//文件上传接口
var galleryUrl = baseUrl + ":17938/get_logo";//获取图库接口
var baseVersionUrl = baseUrl + ":17938/select_basic_version";//获取基础版本接口
var sizeUrl = baseUrl + ":17938/get_size";//获取尺寸接口
var mainMenuStyleUrl = baseUrl + ":17938/get_menu_style";

var token = "Bearer app-arMrKQKkw9YdxKQdFU9BVpnM";//接口令牌
var conversationId = '';//会话ID
var defaultLanguage = [];//默认语言
var allLanguage = [];//所有可用语言
var removedLanguages = [];//不支持语言
var customerName = '浪臣';//客户名
var projectName = '';//项目代号
var allSize = [];//所有尺寸
var resolutions = [];//分辨率
var docId = '';
var pictureGallery = {};//开机，关机logo图库
var pictureMainMenuStyleGallery = {};//主菜单默认风格图库
var baseVersion = [];//基础版本
var currentSize = '';//当前尺寸
var currentScreenShape = '圆屏';//屏幕形状


//var assemblyConfigFilter = [];
// 类别划分
var expandedCategories = {
	'项目常用修改项': true,
	'硬件': false,
	'软件': false
};
var fieldCategories = {
	'项目常用修改项': [
		{
			'field': '组合.蓝牙音频语言组合',
			'label': '',
			'input_type': 'obj',
			'layout_mode': 'inline',
			'show_add_button': false,
			'object_fields': [
				{
					'field': '蓝牙名',
					'input_type': 'text',
					'label': '蓝牙名',
					'key_edit': false,
					'field_path': '软件配置V1.蓝牙名' // 指向原始字段路径
				},
				{
					'field': '音频名',
					'input_type': 'text',
					'label': '音频名',
					'key_edit': false,
					'field_path': '软件配置V1.音频名' // 指向原始字段路径
				}
			]
		},
		{
			'field': '软件配置V2.语言.默认语言',
			'input_type': 'select',
			'label': '默认语言',
			'options': defaultLanguage
		},
		{
			'field': '软件配置V2.语言.新加语言',
			'input_type': 'text',
			'label': '新加语言',
			'key_edit': false
		},
		{
			'field': '软件配置V2.语言.支持语言',
			'input_type': 'doubleselect',
			'label': '',
			'left_label': '支持语言',
			'right_label': '不支持语言',
			'all_items': allLanguage,

		},
		{
			'field': '组合.尺寸屏幕形状组合',
			'label': '',
			'input_type': 'obj',
			'layout_mode': 'inline',
			'show_add_button': false,
			'object_fields': [
				{
					'field': '尺寸',
					'input_type': 'select',
					'label': '尺寸',
					'options': allSize,
					'key_edit': false,
					'attrs': {
						'data-size-select': 'true'
					},
					'field_path': '软件配置V3.尺寸' // 指向原始字段路径
				},
				{
					'field': '屏幕形状',
					'input_type': 'select',
					'label': '屏幕形状',
					'options': ['圆屏','方屏'],
					'key_edit': false,
					'attrs': {
						'data-shape-select': 'true'
					},
					'field_path': '软件配置V3.屏幕形状' // 指向原始字段路径
				},
			]
		},

		{
			'field': '软件配置V3',
			'label': '总成配置',
			'input_type': 'assembly',
			'array_mode': true,
			'add_button_text': '+添加总成',
			'object_fields': [
				{
					'field': '分辨率',
					'label': '分辨率',
					'input_type': 'select',
					'options': resolutions,
					'linked_fields': ['屏', 'TP']  // 添加关联字段
				},
				{
					'field': '屏',
					'label': '屏幕',
					'input_type': 'select',
					'options': []  // 初始为空，将通过分辨率选择动态填充
				},
				{
					'field': 'TP',
					'label': '触摸屏',
					'input_type': 'select',
					'options': []  // 初始为空，将通过分辨率选择动态填充
				}
			]
		},
		
		{
			'field': '组合.基础版本表盘组合',
			'label': '',
			'input_type': 'obj',
			'layout_mode': 'inline',
			'show_add_button': false,
			'object_fields': [
				{
					'field': '基础版本',
					'input_type': 'select',
					'label': '基础版本',
					'options': baseVersion,
					'key_edit': false,
					'field_path': '基础版本' // 指向原始字段路径
				},
				{
					'field': '表盘',
					'input_type': 'image',
					'label': '表盘',
					'key_edit': false,
					'field_path': '软件配置V5.表盘' // 指向原始字段路径
				}
			]
		},
		{
			'field': '软件配置V4.开机',
			'label': '开机',
			'input_type': 'obj',
			'layout_mode': 'inline', //'inline' 或 'block'
			'show_add_button': false, // 隐藏添加按钮
  			'add_button_text': '+添加', // 自定义按钮文案
			"object_fields": [
				{
					"field": "开机震动",
					"input_type": "text",
					"allow_empty": true,
					"key_edit": false,
				},
				{
					"field": "开机logo",
					"input_type": "image",
					"allow_empty": true,
					"key_edit": false,
				
				},
				{
					"field": "开机铃声",
					"input_type": "file",
					"allow_empty": true,
					"key_edit": false,
					'accept': '.mp3,.wav'
				}	
			]
		},
		{
			'field': '软件配置V4.关机',
			'label': '关机',
			'input_type': 'obj',
			'layout_mode': 'inline', //'inline' 或 'block'
			'show_add_button': false, // 隐藏添加按钮
  			'add_button_text': '+添加', // 自定义按钮文案
			'show_toggle_label': false,  // 控制+/-标签是否显示，默认为true
			"object_fields": [
				{
					"field": "关机震动",
					"input_type": "text",
					"key_edit": false,
				},
				{
					"field": "关机logo",
					"input_type": "image",
					"key_edit": false,
				},
				{
					"field": "关机铃声",
					"input_type": "file",
					"key_edit": false,
					'accept': '.mp3,.wav'
				}	
			]
		},
		
	],
	'硬件': [
		{
			'field': '软件配置J1.硬件配置.主板',
			'input_type': 'text',
			'label': '主板'
		},
		{
			'field': '软件配置J1.硬件配置.Flash',
			'input_type': 'text',
			'label': 'Flash'
		},
		{
			'field': '软件配置J1.硬件配置.FPC',
			'input_type': 'text',
			'label': 'FPC'
		},

		{
			'field': '软件配置J1.硬件配置.心率',
			'input_type': 'text',
			'label': '心率'
		},
		{
			'field': '软件配置J1.硬件配置.APP',
			'input_type': 'text',
			'label': 'APP'
		},
		{
			'field': '软件配置J1.硬件配置.充电方式',
			'input_type': 'text',
			'label': '充电方式'
		},
		{
			'field': '软件配置J1.硬件配置.马达',
			'input_type': 'text',
			'label': '马达'
		},
		{
			'field': '壳料',
			'input_type': 'text',
			'label': '壳料'
		}
	],
	'软件': [
		{
			'field': '软件配置J1.TP快捷4方向',
			'label': 'TP快捷4方向',
			'input_type': 'obj',
			'object_fields': []
		},
		{
			'field': '软件配置J1.主菜单风格',
			'label': '主菜单风格',
			'input_type': 'obj',
			"object_fields": [
				// {
				// 	"field": "参考附图",
				// 	"input_type": "image",
				// 	"allow_empty": true,
				// 	"multiple": true,
				// 	"max_files": 5,
				// 	"galleryData": pictureMainMenuStyleGallery,
				// },
			]
		},
		{
			"field": '软件配置J1.参考附图',
			'label':'参考附图',
			"input_type": "image",
			"allow_empty": true,
			"multiple": true,
			"max_files": 5,
			"galleryData": pictureMainMenuStyleGallery,
			"custom_class": "reference-attachment-images",
			"field_path": "软件配置J1.主菜单风格.参考附图",
		},
		{
			'field': '软件配置J1.按键.Power按键',
			'label': 'Power按键',
			'input_type': 'obj',
			'object_fields': []
		},

		{
			'field': '软件配置J1.按键.开关机按键',
			'label': '开关机按键',
			'input_type': 'obj',
			'object_fields': []
		},
		{
			'field': '软件配置J1.按键.编码器按键',
			'label': '编码器按键',
			'input_type': 'obj',
			'object_fields': []
		},
		{
			'field': '软件配置J1.按键.侧键',
			'label': '侧键',
			'input_type': 'obj',
			'object_fields': []
		},
		{
			'field': '软件配置J1.按键.运动侧键',
			'label': '运动侧键',
			'input_type': 'obj',
			'object_fields': []
		},
		{
			'field': '软件配置J1.按键.上按键',
			'label': '上按键',
			'input_type': 'obj',
			'object_fields': []

		},
		{
			'field': '软件配置J1.按键.下按键',
			'label': '下按键',
			'input_type': 'obj',
			'object_fields': []
		},
		{
			'field': '软件配置J1.按键.快捷功能键',
			'label': '快捷功能键',
			'input_type': 'obj',
			'object_fields': []
		},
		{
			'field': '软件配置J2',
			'label': '软件配置J2',
			'input_type': 'objradio'
		},
		{
			'field': '系统功能J3',
			'input_type': 'inputarray',
			'label': '系统功能J3'
		}

	]
};
//页面完全加载后执行的代码
window.onload = async function () {
	enterSend();
	copyText();
	send();
	await getAllSize();
	await getAllGallery();
	firstWlcome = false;
	const configData ={
    "_id": "68a2950c24ad2d12ca9fbd02",
    "id": "9715.xlsx",
    "基础版本": "9662-E06B_L21_LC[H13]_SStyle1_240x284_HryFine_H1.0_AXS5106_16M_HRS-FAKE_DA263_160mA-LC_V1.0_07-20-16-341；",
    "修改": "基础软件：9662-E06B_L21_LC[H13]_SStyle1_240x284_HryFine_H1.0_AXS5106_16M_HRS-FAKE_DA263_160mA-LC_V1.0_07-20-16-34\n更改说明：\n1、增加充电震动；\n",
    "壳料": "",
    "软件配置V1": {
        "蓝牙名": "H13",
        "音频名": "H13"
    },
    "软件配置V2": {
        "语言": {
            "默认语言": "英文",
            "支持语言": "英语、中文、法语、阿拉伯语、德语、印尼语、意大利语、马来西亚语、波斯语、西班牙语、俄语、越语、捷克语、土耳其、波兰语、葡萄牙语、希腊语、菲律宾语、泰语、荷兰、芬兰、乌克兰、瑞典、匈牙利语、希伯来",
            "添加": "：字体标为红色",
            "删除": "：字体标为灰色"
        }
    },
    "软件配置V3": {
		"尺寸": "2.1",
		"屏幕形状": "方屏",
        "总成1": {
            "屏": "中鑫盛，BOE+9853",
            "分辨率": "240*284",
            "TP": "民芳MF-699",
			"尺寸": "2.1",
		"屏幕形状": "方屏",
        },
        "总成2": {
            "屏": "亚创，CTC+3030B",
            "分辨率": "240*286",
            "TP": "",
			"尺寸": "2.1",
			"屏幕形状": "方屏",
        },
        "总成3": {
            "屏": "",
            "分辨率": "",
            "TP": "",
			"尺寸": "2.1",
			"屏幕形状": "方屏",
        },
        "总成4": {
            "屏": "",
            "分辨率": "",
            "TP": "",
			"尺寸": "2.1",
			"屏幕形状": "方屏",
        }
    },
    "软件配置V4": {
        "开机": {
            "开机logo": "http://192.168.69.182:17938/menu_style/方屏/7-平铺栅格.png",
            "开机铃声": "无",
            "开机震动": "有"
        },
        "关机": {
            "关机logo": "Goodbye",
            "关机铃声": "无",
            "关机震动": "有"
        }
    },
    "软件配置V5": {
        "表盘": "表盘编码、表盘贴图"
    },
    "软件配置J1": {
        "硬件配置": {
            "主板": "E06B",
            "FPC": "单按键+4颗灯",
            "APP": "Hryfine",
            "充电方式": "有线充",
            "Flash": "16M",
            "按键": "",
            "编码器": "",
            "LED": "",
            "心率": "假心率4颗灯",
            "壳料型号": "",
            "电池规格": {
                "规格": "",
                "容量": ""
            },
            "支付宝": "",
            "喇叭": {
                "额定功率": ""
            }
        },
        "TP快捷4方向": {
            "上拉": "【智能堆栈】",
            "下拉": "【信息通知】",
            "从上往下拉": "",
            "从下往上拉": "",
            "左右滑": "",
            "左滑": "",
            "右滑": "",
            "从左侧边拉": "",
            "侧边左滑": "表盘预览",
            "侧边右滑": "【快捷组件】",
            "表盘预览": "向左滑动",
            "设置": ""
        },
        "主菜单风格": {
            "参考附图": ["http://192.168.69.182:17938/menu_style/方屏/7-平铺栅格.png","http://192.168.69.182:17938/menu_style/方屏/2-列表.png"],
            "添加": " ：字体标为红色",
            "删除": " ：字体标为灰色"

        },
        "按键": {
            "Power按键": {
                "单击": "：【表盘界面点击进入主界面、其余界面点击返回上级界面】",
                "双击": "：【主界面切换风格】",
                "长按": "：【任何界面触发关机界面、10秒复位】"
            },
            "开关机按键": {
                "单击": "",
                "双击": "",
                "长按": ""
            },
            "编码器按键": {
                "单击": "",
                "双击": "",
                "长按": "",
                "编码器": ""
            },
            "功能键": {
                "单击": "",
                "双击": "",
                "长按": ""
            },
            "侧键": {
                "单击": "",
                "双击": "",
                "长按": ""
            },
            "运动侧键": {
                "单击": "【进入按键设置】"
            },
			//"运动侧键": "单击【进入按键设置】", 
            "上按键": {},
            "下按键": {},
            "快捷功能键": {}
        }
    },
    "软件配置J2": {
        "心率": "on",
        "血压": "on",
        "血氧": "on",
        "心电图": "on",
        "手电筒": "on",
        "灵动岛": "on",
        "短视频控制": "on",
        "表盘锁": "on",
        "女性健康": "on",
        "程序坞": "on",
        "智能堆栈": "on",
        "快捷组件": "on",
        "微信": "on",
        "QQ": "on",
        "Whatsapp": "on",
        "Facebook": "on",
        "Twitter": "on",
        "赛车": "on",
        "运动23种": "off"
    },
    "系统功能J3": [
        "拨号",
        "电话簿",
        "通话记录",
        "信息",
        "计步",
        "运动",
        "睡眠",
        "久坐",
        "闹钟",
        "蓝牙音乐",
        "呼吸",
        "语音",
        "天气",
        "设置",
        "日历",
        "蓝牙拍照",
        "秒表",
        "震动",
        "计算器",
        "风格",
        "找手机",
        "抬手亮屏",
        "复位",
        "表盘",
        "亮度模式",
        "二维码",
        "关于",
        "时间设置",
        "情景模式",
        "语言设置",
        "密码锁",
        "关机",
        "扫码连接",
        "SOS",
        "开机引导",
        "个人信息",
        "专注模式",
        "按键设置",
        "红点提示",
        "通知提示",
        "隐藏通知内容",
        "自动息屏",
        "盖手息屏",
        "开机引导",
        "床头灯",
        "长亮模式",
        "升级狗",
        "OTA"
    ]
} 
	//通过尺寸更新分辨率
	currentSize = configData.软件配置V3.尺寸;
	await getAllResolutions(currentSize);
	//通过屏幕形状获取主菜单参考附图
	if (configData.软件配置V3.屏幕形状 && configData.软件配置V3.屏幕形状.trim() !== '') {
		currentScreenShape = configData.软件配置V3.屏幕形状;
	}
	await getMainMenuStyleGallery(currentScreenShape);
	// showConfigModalTest(configData, '测试编辑')
	


}



function showConfigModalTest(configData, formTitle) {
	window.currentConfigData = configData;
	defaultLanguage = configData.软件配置V2.语言.支持语言.split('、');
	// 确保allLanguage已初始化
	if (!window.allLanguage) {
		window.allLanguage = ['英语']; // 设置默认值
	}
	// 合并默认语言和配置语言，确保allLanguage包含所有可能的语言选项
	window.allLanguage = [...new Set([...window.allLanguage, ...defaultLanguage])];
	// 将支持语言更新为数组
	configData.软件配置V2.语言.支持语言 = defaultLanguage;
	// 获取当前默认语言
	let currentDefaultLang = configData.软件配置V2.语言.默认语言;
	// 检查默认语言是否在支持语言数组中，如果不在则设置为英语或第一个元素
	if (!defaultLanguage.includes(currentDefaultLang)) {
		if (defaultLanguage.includes('英语')) {
			configData.软件配置V2.语言.默认语言 = '英语';
		} else if (defaultLanguage.length > 0) {
			configData.软件配置V2.语言.默认语言 = defaultLanguage[0];
		}
	}
	// 更新默认语言的选项
	fieldCategories['项目常用修改项'].forEach(field => {
		if (field.field === '软件配置V2.语言.默认语言') {
			field.options = defaultLanguage;
		}
		if (field.field === '软件配置V2.语言.支持语言') {
			field.all_items = allLanguage;
		}

	});

	// 更新fieldCategories中软件配置V3的尺寸字段options
	fieldCategories['项目常用修改项'].forEach(field => {
		if (field.field === '组合.尺寸屏幕形状组合') {
			// 更新分辨率字段的options
			field.object_fields.forEach(subField => {
				if (subField.field === '尺寸') {
					subField.options = allSize;
				}
			});
		}
	});
	//更新分辨率字段的options
	fieldCategories['项目常用修改项'].forEach(field => {
		if (field.field === '软件配置V3') {
			// 更新分辨率字段的options
			field.object_fields.forEach(subField => {
				if (subField.field === '分辨率') {
					subField.options = resolutions;
				}
			});
		}
	});

	// 确保默认值包含在选项中
	ensureDefaultValuesInOptions(configData);

	
	//运动侧键数据类型做一个判断，字符串就用text,对象用obj,如果是数组就用array
	if (typeof configData.软件配置J1.按键.运动侧键 === 'string'){
		fieldCategories['软件'].forEach(field => {
			if (field.field === '软件配置J1.按键.运动侧键') {
				field.input_type = 'text';
			}
		});

	} else if (typeof configData.软件配置J1.按键.运动侧键 === 'object'){
		fieldCategories['软件'].forEach(field => {
			if (field.field === '软件配置J1.按键.运动侧键') {
				field.input_type = 'obj';
			}
		});
	}
	//处理参考附图，将添加，删除编辑为风格描述
	if (!configData.软件配置J1.主菜单风格.风格描述) {
		// 检查是否不包含特定字符串
		configData.软件配置J1.主菜单风格.风格描述 = '';
		const addMainMenuStyle = configData.软件配置J1.主菜单风格.添加;
		const delMainMenuStyle = configData.软件配置J1.主菜单风格.删除;
		if (typeof addMainMenuStyle === 'string' && !addMainMenuStyle.includes('字体标为')) {
			// 如果风格描述存在，则赋值
			configData.软件配置J1.主菜单风格.风格描述 += addMainMenuStyle  + ' ';
		}
		if (typeof delMainMenuStyle === 'string' && !delMainMenuStyle.includes('字体标为')) {
			// 如果风格描述存在，则赋值
			configData.软件配置J1.主菜单风格.风格描述 += delMainMenuStyle + ' ';
		}
	}
	
	// 确保参考附图字段存在且为数组格式
	if (!configData.软件配置J1.主菜单风格.参考附图) {
		configData.软件配置J1.主菜单风格.参考附图 = [];
	} else if (!Array.isArray(configData.软件配置J1.主菜单风格.参考附图)) {
		// 如果存在但不是数组，转换为数组
		const existingValue = configData.软件配置J1.主菜单风格.参考附图;
		configData.软件配置J1.主菜单风格.参考附图 = existingValue ? [existingValue] : [];
	}
	
	//删除configData.软件配置J1.主菜单风格.添加和删除
	delete configData.软件配置J1.主菜单风格.添加;
	delete configData.软件配置J1.主菜单风格.删除;
	delete configData.软件配置V2.语言.添加;
	delete configData.参考附图;
	// 删除不需要的顶级字段
	delete configData.开机logo;
	delete configData.关机logo;
	//获取菜单风格图库
	fieldCategories['软件'].forEach(field => {
		if (field.field === '软件配置J1.主菜单风格') {
			// 更新分辨率字段的options
			field.object_fields.forEach(subField => {
				if (subField.field === '参考附图') {
					subField.galleryData = pictureMainMenuStyleGallery;
				}
			});
		}
	});
	configData.修改 = '   ';
	//更新基础版本
	fieldCategories['项目常用修改项'].forEach(field => {
		if (field.field === '组合.基础版本表盘组合' && field.object_fields) {
			field.object_fields.forEach(subField => {
				if (subField.field === '基础版本') {
					subField.options = baseVersion;
				}
			});
		}
	});
	
	const originalBodyOverflow = document.body.style.overflow;
	// 隐藏背景滚动条
	document.body.style.overflow = 'hidden';
	
	layer.open({
		type: 1,
		title: '',
		area: ['100%', '100%'], // 全屏显示
		maxmin: false, // 不允许最大化/最小化
		content:
			`<div id="form-content" class="form-content">
			</div>`,
		success: function () {
			try {
				const sampleData = configData;
				// 初始化JSON表单生成器并保存实例
				window.formGeneratorInstance = FormGenerator.init({
					container: '#form-content',
					initialData: sampleData,
					fieldCategories: fieldCategories,
					expandedCategories: expandedCategories,
					formTitle: formTitle,
					apiUrl: saveOrderApi
				});
				// 监听上传成功事件
				document.addEventListener('uploadSuccess', function (event) {
					
					try {
						// 删除会话（如果有会话ID）
						const isDeleted = deleteConversation(conversationId);
						if (isDeleted) {
							conversationId = ''; // 只有成功后才清空
						}
						// 显示保存成功提示
						layer.msg('保存成功', { icon: 1 });

						//下载excel,pdf文件
						var excelUrl = event.detail.excel_url;
						var pdfUrl = event.detail.pdf_url;
						// 下载Excel文件
						downloadFile(excelUrl);
						// 下载PDF文件
						downloadFile(pdfUrl);
						//layer.closeAll();
					} catch (error) {
						console.error('上传成功事件处理错误:', error);
						layer.msg('保存失败，请稍后重试', { icon: 2, time: 3000 });
					}
				});

				// 调用函数设置尺寸变化监听
				setupSizeChangeListener();
				
				// 调用函数设置屏幕形状变化监听
				setupScreenShapeChangeListener();

				// 监听上传失败事件
				document.addEventListener('uploadError', function (event) {
					try {
						layer.msg('保存失败，请稍后重试', { icon: 2, time: 3000 });
					} catch (error) {
						layer.msg('保存失败，请稍后重试', { icon: 2, time: 3000 });
					}
				});

			} catch (e) {
				layer.msg('加载失败: ' + e.message, { icon: 2 });
			}
		},
		// 在弹窗关闭后执行的回调
		end: function () {
			try {
				// 调用FormGenerator的静态方法清理滚动事件
				FormGenerator.cleanupScrollEvents();
				// 恢复body滚动条样式
				document.body.style.overflow = originalBodyOverflow;
			} catch (error) {
				console.error('清理滚动事件监听器失败:', error);
				// 出错时也尝试恢复滚动条
				document.body.style.overflow = originalBodyOverflow;
			}
		}
	});
}

// 屏幕形状下拉菜单变化监听
function setupScreenShapeChangeListener() {
    // 查找屏幕形状下拉菜单元素
    const shapeSelectElement = document.querySelector('[data-shape-select="true"]');
    
    if (shapeSelectElement) {
        // 添加change事件监听
        shapeSelectElement.addEventListener('change', async function(e) {
            const newScreenShape = e.target.value;
            
            try {
                // 显示加载中提示
                layer.load(2, {
                    content: '正在更新主菜单风格图库...',
                    success: function(layero){
                        layero.find('.layui-layer-content').css({
                            'padding-top': '40px',
                            'width': '70px'
                        });
                    }
                });
                
                // 更新全局屏幕形状变量
                currentScreenShape = newScreenShape;
                
                // 重新获取主菜单风格图库
                await getMainMenuStyleGallery(currentScreenShape);
                
                // 更新软件配置J1.主菜单风格.参考附图的图库数据
                fieldCategories['软件'].forEach(field => {
                    if (field.field === '软件配置J1.主菜单风格') {
                        field.object_fields.forEach(subField => {
                            if (subField.field === '参考附图') {
                                subField.galleryData = pictureMainMenuStyleGallery;
                            }
                        });
                    }
                });
                
                // 触发自定义事件，通知所有相关组件更新图库
                const galleryUpdateEvent = new CustomEvent('galleryDataUpdated', {
                    detail: {
                        fieldName: '参考附图',
                        newGalleryData: pictureMainMenuStyleGallery,
                        screenShape: newScreenShape
                    }
                });
                document.dispatchEvent(galleryUpdateEvent);
                
                // 关闭加载提示
                layer.closeAll('loading');
                
                // 显示成功提示
                layer.msg(`已更新为${newScreenShape}风格图库`, { icon: 1, time: 2000 });
                
            } catch (error) {
                console.error('更新主菜单风格图库失败:', error);
                layer.closeAll('loading');
                layer.msg('更新图库失败，请稍后重试', { icon: 2, time: 3000 });
            }
        });
        
    } else {
    }
}

// 尺寸下拉菜单变化监听
function setupSizeChangeListener() {
    // 查找尺寸下拉菜单元素
    const sizeSelectElement = document.querySelector('[data-size-select="true"]');
    
    if (sizeSelectElement) {
        // 添加change事件监听
        sizeSelectElement.addEventListener('change', async function(e) {
            const newSize = e.target.value;
            
            try {
                // 显示加载中提示
                layer.load(2);
                
                // 保存当前所有自定义分辨率选项，包括"自定义"选项
                const customResolutions = new Set();
                const resolutionSelects = document.querySelectorAll('select[data-field*="分辨率"]');
                resolutionSelects.forEach(select => {
                    Array.from(select.options).forEach(option => {
                        // 特别保留"自定义"选项
                        if (option.textContent === '自定义' || !resolutions.includes(option.value)) {
                            customResolutions.add(option.value);
                        }
                    });
                });
                currentSize = newSize;
                // 根据新的尺寸获取分辨率数据
                await getAllResolutions(newSize);
                
                // 将自定义选项添加回resolutions数组，但不包括"自定义"本身
                // 因为我们会单独在最后添加它
                customResolutions.forEach(customRes => {
                    if (customRes !== '自定义' && !resolutions.includes(customRes)) {
                        resolutions.push(customRes);
                    }
                });
                
                // 更新所有分辨率下拉菜单
                resolutionSelects.forEach(select => {
                    // 保存当前选中的值
                    const currentValue = select.value;
                    
                    // 清空现有选项
                    select.innerHTML = '';
                    
                    // 先添加所有其他分辨率选项（不包括"自定义"）
                    resolutions.forEach(resolution => {
                        if (resolution !== '自定义') {
                            const option = document.createElement('option');
                            option.value = resolution;
                            option.textContent = resolution;
                            // 如果之前的值存在于新选项中，则保持选中
                            if (resolution === currentValue) {
                                option.selected = true;
                            }
                            select.appendChild(option);
							// 触发change事件，确保屏和TP的值同步更新
   							select.dispatchEvent(new Event('change'));

                        }
                    });
                    
                    // 最后添加"自定义"选项到下拉菜单底部
                    const customOption = document.createElement('option');
                    customOption.value = '自定义';
                    customOption.textContent = '自定义';
                    if (currentValue === '自定义') {
                        customOption.selected = true;
                    }
                    select.appendChild(customOption);
                });
            } catch (error) {
                console.error('更新分辨率失败:', error);
                layer.msg('更新分辨率失败，请稍后重试', { icon: 2 });
            } finally {
                // 关闭加载提示
                layer.closeAll('loading');
            }
        });
    }
}
//获取所有的屏幕尺寸getAllSize
async function getAllSize() {
	try {
		const response = await fetch(sizeUrl, {
			method: 'GET',
			headers: {
				'Accept': 'application/json'
			}
		});

		if (response.ok) {
			allSize = await response.json();
		} else {
			console.log('HTTP error! status: ' + response.status);
		}
	} catch (error) {
		console.log('获取尺寸数据时出错:', error);
	}
}

//获取所有的分辨率
async function getAllResolutions(currentSize) {
	try {
		const response = await fetch(resolutionsUrl, {
			method: 'POST',
			headers: {
				'Accept': 'application/json',
				'Content-Type': 'application/json'
			},
			body: JSON.stringify({
				size: currentSize
			})
		});
		if (response.ok) {
			resolutions = await response.json();
		} else {
			console.log('HTTP error! status: ' + response.status);
		}
	} catch (error) {
		console.log('获取分辨率数据时出错:', error);
	}
}
//获取主菜单参考附图
async function getMainMenuStyleGallery(currentScreenShape) {
	try {
		const response = await fetch(mainMenuStyleUrl, {
			method: 'POST',
			headers: {
				'Accept': 'application/json',
				'Content-Type': 'application/json'
			},
			body: JSON.stringify({
				type: currentScreenShape
			})
		});
		if (response.ok) {
			res = await response.json();
			var row = [];
			//循环file_name_array，拼接 file_url+file_name_array[i]，赋值给pictureMainMenuStyleGallery
			for (let i = 0; i < res.file_name_array.length; i++) {
				row.push(res.file_url + res.file_name_array[i]);
			}
			pictureMainMenuStyleGallery = {[currentScreenShape]: row};
			console.log(pictureMainMenuStyleGallery);
			
		} else {
			console.log('HTTP error! status: ' + response.status);
		}
	} catch (error) {
		console.log('获取主菜单参考附图数据时出错:', error);
	}
}

//获取基础版本 
async function getBaseVersion() {
	try {
		const response = await fetch(baseVersionUrl, {
			method: 'POST',
			headers: {
				'Accept': 'application/json',
				'Content-Type': 'application/json'
			},
			body: JSON.stringify({
				customer_name: customerName,
				customer_prj_no: projectName,
			})
		});
		if (response.ok) {
			const data = await response.json();
			baseVersion = data;

		} else {
			console.log('HTTP error! status: ' + response.status);
		}
	} catch (error) {
		console.log('获取语言数据时出错:', error);
	}
}

//获取所有的语言
async function getAllLanguages() {
	try {
		const response = await fetch(languageUrl, {
			method: 'POST',
			headers: {
				'Accept': 'application/json',
				'Content-Type': 'application/json'
			},
			body: JSON.stringify({
				needs_id: docId
			})
		});
		console.log('docid:', docId);

		if (response.ok) {
			const data = await response.json();
			languages = data?.['支持语言'] || [];
			//console.log('获取到的语言:', languages);
			// 确保allLanguage已初始化
			if (!window.allLanguage) {
				window.allLanguage = ['英语']; // 设置默认值
			}
			// 合并现有语言和新获取的语言，避免覆盖
			window.allLanguage = [...new Set([...window.allLanguage, ...languages])];
			allLanguage = window.allLanguage;
			//console.log('合并后的语言:', window.allLanguage);

		} else {
			console.log('HTTP error! status: ' + response.status);
		}
	} catch (error) {
		console.log('获取语言数据时出错:', error);
	}
}

//根据分辨率获取总成数据
async function getAssemblyByResolution(resolution) {
	try {
		// 准备请求数据
		const requestData = {
			resolution: currentSize + '-' + resolution,
			customer_name: customerName
		};
		// 使用fetch发送POST请求
		const response = await fetch(assemblyUrl, {
			method: 'POST',
			headers: {
				'Accept': 'application/json',
				'Content-Type': 'application/json'
			},
			body: JSON.stringify(requestData)
		});

		// 检查响应是否成功
		if (!response.ok) {
			throw new Error(`HTTP error! status: ${response.status}`);
		}

		// 解析JSON数据
		const data = await response.json();

		// 处理获取到的总成数据
		//console.log('获取到的总成数据:', data);
		assemblyConfigFilter = data;
		// 处理获取到的总成数据,新字段screen = 玻璃 + 屏厂 + 屏IC;新字段tp = TP厂家 + TP丝印
		const screenSet = new Set();
		const tpSet = new Set();
		// 处理数据并填充Set
		data.forEach(item => {
			item.screen = item.玻璃 + item.屏厂 + item.屏IC;
			item.tp = item.TP厂家 + item.TP丝印;

			// 将值添加到Set中实现去重
			screenSet.add(item.screen);
			tpSet.add(item.tp);
		});

		// 将Set转换为对象数组
		const screenArray = Array.from(screenSet).map(screen => ({ screen }));
		const tpArray = Array.from(tpSet).map(tp => ({ tp }));
		return {
			screenArray: screenArray,
			tpArray: tpArray,
		};
	} catch (error) {
		// 处理错误
		console.error('获取总成数据时出错:', error);
		throw error;
	}
}

// 确保默认值包含在选项中
function ensureDefaultValuesInOptions(configData) {
	// 获取软件配置V3的总成数据
	const assemblyData = configData.软件配置V3 || {};
	
	// 收集所有默认值
	const defaultScreenValues = new Set();
	const defaultTpValues = new Set();
	const defaultResolutionValues = new Set();
	
	// 遍历所有总成，收集默认值
	Object.keys(assemblyData).forEach(key => {
		if (key.includes('总成')) {
			const assembly = assemblyData[key];
			if (assembly.屏 && assembly.屏.trim() !== '') {
				defaultScreenValues.add(assembly.屏);
			}
			if (assembly.TP && assembly.TP.trim() !== '') {
				defaultTpValues.add(assembly.TP);
			}
			if (assembly.分辨率 && assembly.分辨率.trim() !== '') {
				defaultResolutionValues.add(assembly.分辨率);
			}
		}
	});
	
	// 更新fieldCategories中的选项
	fieldCategories['项目常用修改项'].forEach(field => {
		if (field.field === '软件配置V3' && field.object_fields) {
			field.object_fields.forEach(subField => {
				// 处理分辨率字段
				if (subField.field === '分辨率') {
					// 确保resolutions数组包含默认值
					defaultResolutionValues.forEach(defaultValue => {
						if (!resolutions.includes(defaultValue)) {
							resolutions.unshift(defaultValue); // 添加到开头
						}
					});
					subField.options = resolutions;
				}
				// 处理屏字段
				else if (subField.field === '屏') {
					// 初始化屏选项数组（如果没有的话）
					if (!subField.options) {
						subField.options = [];
					}
					// 添加默认值到选项中
					defaultScreenValues.forEach(defaultValue => {
						if (!subField.options.includes(defaultValue)) {
							subField.options.unshift(defaultValue); // 添加到开头
						}
					});
				}
				// 处理TP字段
				else if (subField.field === 'TP') {
					// 初始化TP选项数组（如果没有的话）
					if (!subField.options) {
						subField.options = [];
					}
					// 添加默认值到选项中
					defaultTpValues.forEach(defaultValue => {
						if (!subField.options.includes(defaultValue)) {
							subField.options.unshift(defaultValue); // 添加到开头
						}
					});
				}
			});
		}
	});
	
	console.log('已确保默认值包含在选项中:', {
		屏: Array.from(defaultScreenValues),
		TP: Array.from(defaultTpValues),
		分辨率: Array.from(defaultResolutionValues)
	});
}
//获取所有的图库
async function getAllGallery() {
	try {
		const response = await fetch(galleryUrl, {
			method: 'GET',
			headers: {
				'Accept': 'application/json'
			}
		});

		if (response.ok) {
			const data = await response.json();
			pictureGallery = data;
		} else {
			console.log('HTTP error! status: ' + response.status);
		}
	} catch (error) {
		console.log('获取图库数据时出错:', error);
	}
}

// 删除会话
async function deleteConversation(conversationId) {
	if (!conversationId) return false;

	try {
		const response = await fetch(delConversationApi + '/' + conversationId, {
			method: 'DELETE',
			headers: {
				'Authorization': token,
				'Content-Type': 'application/json'
			},
			body: JSON.stringify({
				user: "abc-123"
			})
		});

		// 检查响应状态
		if (!response.ok) {
			throw new Error(`删除失败，状态码: ${response.status}`);
		}

		console.log(`会话 ${conversationId} 已删除`);
		return true;
	} catch (error) {
		console.error('删除会话出错:', error);
		// 可以选择重试或上报错误
		return false;
	}
}

//文件上传接口
async function uploadFile(file) {
	const formData = new FormData();
	formData.append('file', file);

	try {
		const response = await fetch(uploadUrl, {
			method: 'POST',
			headers: {
				'accept': 'application/json'
			},
			body: formData
		});

		if (response.ok) {
			const data = await response.json();
			console.log('文件上传成功:', data);
			// 返回url数据，没有则返回空
			return data.url || '';
		} else {
			console.error('文件上传失败:', response.status, response.statusText);
			return '';
		}
	} catch (error) {
		console.error('文件上传出错:', error);
		return '';
	}
}

// 添加downloadFile函数
function downloadFile(url) {
    // 检查URL是否存在且不为空
    if (url && url.trim() !== '') {
        // 使用fetch API获取文件内容
        fetch(url)
            .then(response => {
                if (!response.ok) {
                    throw new Error('Network response was not ok');
                }
                return response.blob();
            })
            .then(blob => {
                // 创建一个临时的URL
                const blobUrl = window.URL.createObjectURL(blob);
                
                // 创建一个临时的<a>标签来触发下载
                var link = document.createElement('a');
                link.href = blobUrl;
                link.style.display = 'none';
                
                // 尝试从URL中提取文件名
                var filename = url.split('/').pop().split('?')[0];
                if (!filename) {
                    filename = 'download.pdf'; // 默认文件名
                }
                
                // 设置下载属性和文件名
                link.setAttribute('download', filename);
                
                // 添加到DOM中
                document.body.appendChild(link);
                
                // 触发点击事件
                link.click();
                
                // 在下一个事件循环中移除元素和URL
                setTimeout(function() {
                    document.body.removeChild(link);
                    window.URL.revokeObjectURL(blobUrl);
                }, 100);
            })
            .catch(error => {
                console.error('下载文件时出错:', error);
                // 如果fetch失败，回退到原来的方法
                fallbackDownload(url);
            });
    } else {
        console.log('URL不存在或为空，跳过下载');
    }
}

// 回退方法
function fallbackDownload(url) {
    // 创建一个临时的<a>标签来触发下载
    var link = document.createElement('a');
    link.href = url;
    link.style.display = 'none';
    
    // 尝试从URL中提取文件名
    var filename = url.split('/').pop().split('?')[0];
    if (filename) {
        link.setAttribute('download', filename);
    } else {
        link.setAttribute('download', '');
    }
    
    // 添加到DOM中
    document.body.appendChild(link);
    
    // 触发点击事件
    link.click();
    
    // 在下一个事件循环中移除元素
    setTimeout(function() {
        document.body.removeChild(link);
    }, 100);
}

// 添加HTML实体解码函数
function decodeHtmlEntities(html) {
    var txt = document.createElement('textarea');
    txt.innerHTML = html;
    return txt.value;
}

// 对话输出后滚动聊天底部
function forceScrollToBottom() {
	const container = document.querySelector(".conversation");
	if (!container) return;

	// 立即跳转（确保到位）
	container.scrollTop = container.scrollHeight;

	// 平滑滚动（视觉增强）
	requestAnimationFrame(() => {
		const lastChild = container.lastElementChild;
		if (lastChild) {
			lastChild.scrollIntoView({
				behavior: 'smooth',
				block: 'end'
			});
		}
	});
}

//监视复制事件,去掉复制文案样式
var copyText = function () {
	// 获取选中的文本
	document.addEventListener('copy', function (e) {
		// 获取选中的文本
		const selection = window.getSelection();
		const selectedText = selection.toString();
		// 阻止默认复制行为
		e.preventDefault();
		// 设置纯文本到剪贴板
		e.clipboardData.setData('text/plain', selectedText);
	});
}
//监视回车发送
var enterSend = function () {
	$("#text_in").on('keypress', function (e) {
		if (e.which === 13 && !e.shiftKey) {  // 13是回车键
			e.preventDefault();  // 阻止默认换行行为
			send();  // 调用发送函数
			return false;
		}
	});
}
// 发送消息
var send = function () {
	let fullAnswer = '';
	let messageElement = null;
	let newPcb = null;
	let shouldIncludeNewPcb = false;
	let loadingAnimation = null;

	// 获取输入框内容并立即去除首尾空格
	var msg = $.trim($("#text_in").html())
	// 解码HTML实体（如&nbsp;）
	msg = decodeHtmlEntities(msg);
	// 去除首尾空格
	msg = $.trim(msg);
	if (!firstWlcome) {
		if (msg == '') {
			layer.msg('请输入信息');
			return;
		}
	}
	// 处理消息时间
	var time;
	if ($.cookie("itime") == "") {
		var myDate = new Date();
		time = myDate.getHours() + ":" + myDate.getMinutes();
		var timestamp = Date.parse(new Date());
		$.cookie("itime", timestamp / 1000);
	} else {
		var timestamp = Date.parse(new Date());
		var lasttime = $.cookie("itime");
		if ((timestamp / 1000 - lasttime) > 30) {
			var myDate = new Date(timestamp * 1000);
			time = myDate.getHours() + ":" + myDate.getMinutes();
		} else {
			time = "";
		}
		$.cookie("itime", timestamp / 1000);
	}

	// 显示用户发送的消息
	var str = '';
	str += '<li class="chatmsg"><div class="showtime">' + time + '</div>';
	str += '<div class="" style="position: absolute;top: 26px;right: 2px;"><img  class="my-circle cu_pic" src="' + pic + '" width="40px" height="40px"></div>';
	str += "<div class='outer-right'><div class='customer'>";
	str += "<pre style='background-color: transparent;'>" + msg + "</pre>";
	str += "</div></div>";
	str += "</li>";

	// 先获取query的值，再清空输入框
	var query = msg.trim();

	if (!firstWlcome) {
		$(".conversation").append(str);
	}

	$("#text_in").empty();
	var div = document.getElementById("wrap");
	div.scrollTop = div.scrollHeight;


	if (!query) {
		//默认参数，不传就会报错
		query = '1';
	}
	//console.log('请求前：', query);

	// 会话发送请求
	async function sendStreamingRequest(query) {
		// 显示加载动画
		showLoadingAnimation();
		console.log('请求参数', query);

		// 记录请求开始时间和状态变量
		const requestStartTime = Date.now();
		let requestCompleted = false;
		let thinkingShown = false;
		let searchingShown = false;
		let thinkingTimer, searchingTimer, ellipsisTimer;
		let messageElement = null;
		let fullAnswer = '';

		// 添加打字机效果函数
		function typeWriterEffect(element, text, speed = 50) {
			let i = 0;
			element.text(''); // 清空元素
			return new Promise(resolve => {
				const typeInterval = setInterval(() => {
					if (i < text.length && !requestCompleted) {
						element.append(text.charAt(i));
						i++;
					} else {
						clearInterval(typeInterval);
						resolve();
					}
				}, speed);
			});
		}

		// 添加动态省略号函数
		function animateEllipsis(element) {
			let dots = 0;
			return setInterval(() => {
				if (requestCompleted) return;
				dots = (dots + 1) % 4;
				element.text(element.text().replace(/\.{0,3}$/, '.'.repeat(dots)));
			}, 500);
		}

		try {
			// 设置2秒提示定时器
			thinkingTimer = setTimeout(() => {
				if (!requestCompleted && !thinkingShown) {
					thinkingShown = true;
					// 创建消息元素并立即显示提示文本
					const msgHtml = `
                <li class="chatmsg_notice">
                    <div style="position: absolute;left:3px;">
                        <img class="my-circle" src="${robotImg}" width="40px" height="40px">
                    </div>
                    <div class='outer-left'><div class='service'>
                        <pre style='line-height:30px;'>我正在思考</pre>
                    </div></div>
                </li>
            `;
					$("#wrap .conversation").append(msgHtml);
					messageElement = $("#wrap .conversation li:last-child pre");

					// 添加动态省略号
					ellipsisTimer = animateEllipsis(messageElement);
					forceScrollToBottom();
				}
			}, 2000);

			// 设置15秒提示定时器
			searchingTimer = setTimeout(() => {
				if (!requestCompleted && !searchingShown) {
					searchingShown = true;
					if (messageElement) {
						// 清除之前的省略号动画
						clearInterval(ellipsisTimer);
						// 更新提示文本
						messageElement.text("我正在搜索历史项目");
						// 添加动态省略号
						ellipsisTimer = animateEllipsis(messageElement);
						forceScrollToBottom();
					}
				}
			}, 15000);

			// 构建请求参数
			const requestData = {
				inputs: {},
				query: query,
				response_mode: "streaming",
				user: "abc-123",
				files: [{}]
			};

			// 携带会话ID
			if (conversationId) {
				requestData.conversation_id = conversationId;
				console.log('携带会话ID:', conversationId);
			}

			// 添加new_pcb属性
			if (shouldIncludeNewPcb && newPcb !== null) {
				requestData.inputs.new_pcb = newPcb;
				shouldIncludeNewPcb = false;
			}

			// 发送请求
			const response = await fetch(messageChatApi, {
				method: 'POST',
				headers: {
					'Authorization': token,
					'Content-Type': 'application/json'
				},
				body: JSON.stringify(requestData)
			});

			if (!response.ok) {
				throw new Error(`HTTP error! status: ${response.status}`);
			}

			// 处理流式响应
			const reader = response.body.getReader();
			const decoder = new TextDecoder();
			let buffer = '';

			while (true) {
				const { done, value } = await reader.read();
				if (done) break;

				buffer += decoder.decode(value, { stream: true });
				const lines = buffer.split('\n');
				buffer = lines.pop();

				for (const line of lines) {
					if (line.trim() === '') continue;

					try {
						// 解析消息
						let data = line.startsWith('data: ') ? JSON.parse(line.substring(6)) : JSON.parse(line);

						// 收到有效回答时终止提示
						if (data.event === "node_finished" && data.data?.node_type === "answer") {
							clearTimeout(thinkingTimer);
							clearTimeout(searchingTimer);
							clearInterval(ellipsisTimer);
							thinkingShown = true;
							searchingShown = true;
						}

						if (data.event === "node_finished") {
							// 处理回答内容
							if (data.data?.node_type === "answer" && data.data?.outputs?.answer) {
								// 创建正式消息元素（如果不存在）
								if (!messageElement) {
									const msgHtml = `
                                <li class="chatmsg_notice">
                                    <div style="position: absolute;left:3px;">
                                        <img class="my-circle" src="${robotImg}" width="40px" height="40px">
                                    </div>
                                    <div class='outer-left'><div class='service'>
                                        <pre style='line-height:30px;'></pre>
                                    </div></div>
                                </li>
                            `;
									$("#wrap .conversation").append(msgHtml);
									messageElement = $("#wrap .conversation li:last-child pre");
								}

								fullAnswer += data.data.outputs.answer;
								messageElement.text(fullAnswer);
								forceScrollToBottom();

								if (data.conversation_id) {
									conversationId = data.conversation_id;
								}

								// 重置状态
								fullAnswer = '';
								messageElement = null;
							}

							// 处理开板状态
							if (data.data?.title === "return_new_pcb") {
								newPcb = data.data.inputs.arg1;
								shouldIncludeNewPcb = newPcb === 0;
							}


							// 处理订单号
							if (data.data?.title === "return_order_number" && data.data?.inputs?.id) {
								console.log('获取到的订单号：', data.data.inputs.id);
								console.log('获取到的客户名：', data.data.inputs.customer_name);
								console.log('获取到的项目代号：', data.data.inputs.project_name);
								customerName = data.data?.inputs?.customer_name || '';
								projectName = data.data?.inputs?.project_name || '';
								docId = data.data.inputs.id;
								await fetchDocumentConfig(data.data.inputs.id);

							}
						}
						// 处理错误
						else if (data.event === "error") {
							throw new Error(data.message || "服务器处理出错");
						}
					} catch (e) {
						console.log('解析错误:', e);
					}
				}
			}
		} catch (error) {
			console.log('请求出错:', error);
			layer.msg(`<span style="color: red;">${error.message || '服务器处理请求时出错'}</span>`, {
				time: 5000,
				icon: 2
			});
		} finally {
			// 标记请求完成并清理定时器
			requestCompleted = true;
			clearTimeout(thinkingTimer);
			clearTimeout(searchingTimer);
			clearInterval(ellipsisTimer); // 清除省略号动画定时器
			hideLoadingAnimation();
		}


		// 新增加载动画函数
		function showLoadingAnimation() {
			// 锁定输入框
			$("#text_in").attr("contenteditable", "false").css("background-color", "#f5f5f5");

			// 修改发送按钮状态
			$(".layui-btn").attr("disabled", true)
				.text("回复中...")
				.css("background-color", "#cccccc")
				.css("cursor", "not-allowed");
		}
		// 隐藏加载动画
		function hideLoadingAnimation() {
			// 解锁输入框
			$("#text_in").attr("contenteditable", "true").css("background-color", "");

			// 恢复发送按钮状态
			$(".layui-btn").attr("disabled", false)
				.text("发送")
				.css("background-color", "")
				.css("cursor", "pointer");

			if (loadingAnimation) {
				layer.close(loadingAnimation);
				loadingAnimation = null;
			}
		}

		// 获取文档配置信息
		async function fetchDocumentConfig(docId) {
			try {
				const response = await fetch(documentApi, {
					method: 'POST',
					mode: 'cors',
					headers: {
						'accept': 'application/json',
						'Content-Type': 'application/json'
					},
					body: JSON.stringify({ doc_id: docId })
				});

				if (!response.ok) {
					throw new Error(`获取文档配置失败! status: ${response.status}`);
				}

				const configData = await response.json();
				console.log("获取到的文档配置信息:", configData);

				// 显示配置弹窗
				var newDocId = docId.substring(0, docId.lastIndexOf('.'));
				var formTitle = '需求' + newDocId + '编辑';
				await getAllLanguages();
				await getBaseVersion();
				//通过尺寸更新分辨率
				currentSize = configData.软件配置V3.尺寸;
				await getAllResolutions(currentSize);
				//通过屏幕形状获取主菜单参考附图
				if (configData.软件配置V3.屏幕形状 && configData.软件配置V3.屏幕形状.trim() !== '') {
					currentScreenShape = configData.软件配置V3.屏幕形状;
				}
				await getMainMenuStyleGallery(currentScreenShape);

				// 确保默认值包含在选项中
				ensureDefaultValuesInOptions(configData);

				showConfigModal(configData, formTitle);

				return configData;
			} catch (error) {
				console.log('获取文档配置出错:', error);
				layer.msg('获取配置失败: ' + error.message);
				throw error;
			}
		}
		// 显示JSON订单配置弹窗
		function showConfigModal(configData, formTitle) {
			window.currentConfigData = configData;
			defaultLanguage = configData.软件配置V2.语言.支持语言.split('、');
			// 确保allLanguage已初始化
			if (!window.allLanguage) {
				window.allLanguage = ['英语']; // 设置默认值
			}
			// 合并默认语言和配置语言，确保allLanguage包含所有可能的语言选项
			window.allLanguage = [...new Set([...window.allLanguage, ...defaultLanguage])];
			// 将支持语言更新为数组
			configData.软件配置V2.语言.支持语言 = defaultLanguage;
			// 获取当前默认语言
			let currentDefaultLang = configData.软件配置V2.语言.默认语言;
			// 检查默认语言是否在支持语言数组中，如果不在则设置为英语或第一个元素
			if (!defaultLanguage.includes(currentDefaultLang)) {
				if (defaultLanguage.includes('英语')) {
					configData.软件配置V2.语言.默认语言 = '英语';
				} else if (defaultLanguage.length > 0) {
					configData.软件配置V2.语言.默认语言 = defaultLanguage[0];
				}
			}
			// 更新默认语言的选项
			fieldCategories['项目常用修改项'].forEach(field => {
				if (field.field === '软件配置V2.语言.默认语言') {
					field.options = defaultLanguage;
				}
				if (field.field === '软件配置V2.语言.支持语言') {
					field.all_items = allLanguage;
				}

			});

			// 更新fieldCategories中软件配置V3的尺寸字段options
			fieldCategories['项目常用修改项'].forEach(field => {
				if (field.field === '组合.尺寸屏幕形状组合') {
					// 更新分辨率字段的options
					field.object_fields.forEach(subField => {
						if (subField.field === '尺寸') {
							subField.options = allSize;
						}
					});
				}
			});
			//更新分辨率字段的options
			fieldCategories['项目常用修改项'].forEach(field => {
				if (field.field === '软件配置V3') {
					// 更新分辨率字段的options
					field.object_fields.forEach(subField => {
						if (subField.field === '分辨率') {
							subField.options = resolutions;
						}
					});
				}
			});

			
			//运动侧键数据类型做一个判断，字符串就用text,对象用obj,如果是数组就用array
			if (typeof configData.软件配置J1.按键.运动侧键 === 'string'){
				fieldCategories['软件'].forEach(field => {
					if (field.field === '软件配置J1.按键.运动侧键') {
						field.input_type = 'text';
					}
				});

			} else if (typeof configData.软件配置J1.按键.运动侧键 === 'object'){
				fieldCategories['软件'].forEach(field => {
					if (field.field === '软件配置J1.按键.运动侧键') {
						field.input_type = 'obj';
					}
				});
			}
			//处理参考附图，将添加，删除编辑为风格描述
			if (!configData.软件配置J1.主菜单风格.风格描述) {
				// 检查是否不包含特定字符串
				configData.软件配置J1.主菜单风格.风格描述 = '';
				const addMainMenuStyle = configData.软件配置J1.主菜单风格.添加;
				const delMainMenuStyle = configData.软件配置J1.主菜单风格.删除;
				if (typeof addMainMenuStyle === 'string' && !addMainMenuStyle.includes('字体标为')) {
					// 如果风格描述存在，则赋值
					configData.软件配置J1.主菜单风格.风格描述 += addMainMenuStyle  + ' ';
				}
				if (typeof delMainMenuStyle === 'string' && !delMainMenuStyle.includes('字体标为')) {
					// 如果风格描述存在，则赋值
					configData.软件配置J1.主菜单风格.风格描述 += delMainMenuStyle + ' ';
				}
			}
			
			// 确保参考附图字段存在且为数组格式
			if (!configData.软件配置J1.主菜单风格.参考附图) {
				configData.软件配置J1.主菜单风格.参考附图 = [];
			} else if (!Array.isArray(configData.软件配置J1.主菜单风格.参考附图)) {
				// 如果存在但不是数组，转换为数组
				const existingValue = configData.软件配置J1.主菜单风格.参考附图;
				configData.软件配置J1.主菜单风格.参考附图 = existingValue ? [existingValue] : [];
			}
			
			// 确保开机和关机字段结构存在
			if (!configData.软件配置V4) {
				configData.软件配置V4 = {};
			}
			if (!configData.软件配置V4.开机) {
				configData.软件配置V4.开机 = {};
			}
			if (!configData.软件配置V4.关机) {
				configData.软件配置V4.关机 = {};
			}
			// 确保开机logo和关机logo字段存在
			if (configData.软件配置V4.开机 && !configData.软件配置V4.开机.开机logo) {
				configData.软件配置V4.开机.开机logo = '';
			}
			if (configData.软件配置V4.关机 && !configData.软件配置V4.关机.关机logo) {
				configData.软件配置V4.关机.关机logo = '';
			}
			
			//删除configData.软件配置J1.主菜单风格.添加和删除
			delete configData.软件配置J1.主菜单风格.添加;
			delete configData.软件配置J1.主菜单风格.删除;
			delete configData.软件配置V2.语言.添加;
			delete configData.参考附图;
			// 删除不需要的顶级字段
			delete configData.开机logo;
			delete configData.关机logo;
			console.log('已删除不需要的顶级字段: 参考附图, 开机logo, 关机logo');
			
			//获取菜单风格图库
			fieldCategories['软件'].forEach(field => {
				if (field.field === '软件配置J1.主菜单风格') {
					// 更新分辨率字段的options
					field.object_fields.forEach(subField => {
						if (subField.field === '参考附图') {
							subField.galleryData = pictureMainMenuStyleGallery;
						}
					});
				}
			});
			configData.修改 = '   ';
			//更新基础版本
			fieldCategories['项目常用修改项'].forEach(field => {
				if (field.field === '组合.基础版本表盘组合' && field.object_fields) {
					field.object_fields.forEach(subField => {
						if (subField.field === '基础版本') {
							subField.options = baseVersion;
						}
					});
				}
			});
			
			const originalBodyOverflow = document.body.style.overflow;
			// 隐藏背景滚动条
			document.body.style.overflow = 'hidden';
			layer.open({
				type: 1,
				title: '',
				area: ['100%', '100%'], // 全屏显示
				maxmin: false, // 不允许最大化/最小化
				content:
					`<div id="form-content" class="form-content">
					</div>`,
				success: function () {
					try {
						const sampleData = configData;
						// 初始化JSON表单生成器并保存实例
						window.formGeneratorInstance = FormGenerator.init({
							container: '#form-content',
							initialData: sampleData,
							fieldCategories: fieldCategories,
							expandedCategories: expandedCategories,
							formTitle: formTitle,
							apiUrl: saveOrderApi
						});
						// 监听上传成功事件
						document.addEventListener('uploadSuccess', function (event) {
							try {
								console.log('上传成功事件触发:', event.detail);
								// 删除会话（如果有会话ID）
								const isDeleted = deleteConversation(conversationId);
								if (isDeleted) {
									conversationId = ''; // 只有成功后才清空
								}
								// 显示保存成功提示
								layer.msg('保存成功', { icon: 1 });

								//下载excel,pdf文件
								var excelUrl = event.detail.excel_url;
								var pdfUrl = event.detail.pdf_url;
								// 下载Excel文件
								downloadFile(excelUrl);
								// 下载PDF文件
								downloadFile(pdfUrl);
								layer.closeAll();
							} catch (error) {
								console.error('上传成功事件处理错误:', error);
								layer.msg('保存失败，请稍后重试', { icon: 2, time: 3000 });
							}
						});

						// 调用函数设置尺寸变化监听
						setupSizeChangeListener();
						
						// 调用函数设置屏幕形状变化监听
						setupScreenShapeChangeListener();

						// 监听上传失败事件
						document.addEventListener('uploadError', function (event) {
							try {
								console.log('上传失败事件触发:', event.detail);
								layer.msg('保存失败，请稍后重试', { icon: 2, time: 3000 });
							} catch (error) {
								console.error('上传失败事件处理错误:', error);
								layer.msg('保存失败，请稍后重试', { icon: 2, time: 3000 });
							}
						});

					} catch (e) {
						console.error('初始化失败:', e);
						layer.msg('加载失败: ' + e.message, { icon: 2 });
					}
				},
				// 在弹窗关闭后执行的回调
				end: function () {
					try {
						// 调用FormGenerator的静态方法清理滚动事件
						FormGenerator.cleanupScrollEvents();
						// 恢复body滚动条样式
						document.body.style.overflow = originalBodyOverflow;
					} catch (error) {
						console.error('清理滚动事件监听器失败:', error);
						// 出错时也尝试恢复滚动条
						document.body.style.overflow = originalBodyOverflow;
					}
				}
			});
		}
		// 对话输出后滚动聊天底部
		function forceScrollToBottom() {
			const container = document.querySelector(".conversation");
			if (!container) return;

			// 立即跳转（确保到位）
			container.scrollTop = container.scrollHeight;

			// 平滑滚动（视觉增强）
			requestAnimationFrame(() => {
				const lastChild = container.lastElementChild;
				if (lastChild) {
					lastChild.scrollIntoView({
						behavior: 'smooth',
						block: 'end'
					});
				}
			});
		}


	}
	// 初始调用	
	sendStreamingRequest(query);
}
// 添加HTML实体解码函数
function decodeHtmlEntities(html) {
	var txt = document.createElement('textarea');
	txt.innerHTML = html;
	return txt.value;
}